#ifndef _THREAD_HPP__
#define _THREAD_HPP__
#include<pthread.h>
#include<string>
#include<functional>
#include <sys/types.h>
#include <unistd.h>
#include<iostream>


namespace Thread
{
   //verson 2 
    static int number=1;
    enum class STATUS
    {
        NEW,
        RUNING,
        STOP
    };
    const char* to_str(STATUS status) {
    switch (status) {
        case STATUS::NEW: return "NEW";
        case STATUS::RUNING: return "RUNING"; 
        case STATUS::STOP: return "STOP";
        default: return "UNKNOWN";
    }
   }
     std::ostream& operator<<(std::ostream& os, STATUS status) {
        return os << to_str(status);
     }
    template<class T>
    class  myThread
    {
      using fun_c = std::function<void(T&)>;
      private:
      //Routine 必须写成类里的静态函数 因为如果是类成员函数会默认有this指针
      //Routine（myThread* this,void* args）
      static void* Routine(void* args)
      {
        std::cout<<"进入Routinue"<<std::endl;
        myThread<T>* thisthd = static_cast<myThread<T> *>(args);
        thisthd->_status=STATUS::RUNING;
        thisthd->_fun(thisthd->_data);
       
        return nullptr;
      }
      public:
      myThread(fun_c fun,T& data)
      :_fun(fun)
      ,_joinenable(true)
      ,_status(STATUS::NEW)
      ,_data(data)
      {
        _name="Thread" + std::to_string(number++);
        _pid=getpid();
        
        
      }
      bool Start()
      {
      
            if(_status == STATUS::NEW)
            {
                std::cout<<"进入strat"<<std::endl;
                int n = pthread_create(&_tid,nullptr,Routine,this);
                if(n != 0)
                {
                    std::cout<<"创建线程失败"<<std::endl;
                    return false;
                }
                std::cout<<"创建成功"<<n<<std::endl;
                return true; 
            }
            return false;
      
      }
      bool Join()
      {
        if(_joinenable&&_status==STATUS::RUNING)
        {
            int n  = pthread_join(_tid,nullptr);
            if(n!=0)
            {
                std::cout<<"等待线程失败1"<<std::endl;
                return false;
            }
            //join住了线程就要终止了
            _status= STATUS::STOP;
            return true;
        }
        std::cout<<"等待线程失败2"<<"join"<<_joinenable<<" _stauts"<<_status<<std::endl;
        return false;
      }
      bool Stop()
      {
            if(_status==STATUS::RUNING)
            {
                int n = pthread_cancel(_tid);
                if(n != 0)
                {
                    std::cout<<"终止线程失败"<<std::endl;
                    return false;
                }
                _status=STATUS::STOP;
                return true;
            }
            return false;
      }
      void Detach()
      {
        _joinenable=false;
        pthread_detach(_tid);
      }
      std::string Name()
      {
        return _name;
      }
      bool isJoin()//等待的状态 // 是否可以分离
      {
        return _joinenable;
      }

     private:
        std::string _name;
        pthread_t _tid;//线程的tid
        pid_t _pid;//进程的pid
        bool _joinenable;//是否被等待回收  默认是被等待 或 可不可以分离 否  
        fun_c _fun;
        STATUS _status;
        T& _data;
    };



};























// namespace Thread
// {
//     using fun_c = std::function<void()>;
//     static int number=1;
//     enum class STATUS
//     {
//         NEW,
//         RUNING,
//         STOP
//     };
//     class  myThread
//     {
//      private:


//       public:
//       //Routine 必须写成类里的静态函数 因为如果是类成员函数会默认有this指针
//       //Routine（myThread* this,void* args）
//       static void* Routine(void* args)
//       {
//         myThread* thisthd = static_cast<myThread*>(args);
//         thisthd->_status=STATUS::RUNING;
//         thisthd->_fun();
       
//         return nullptr;
//       }
//       myThread(fun_c fun)
//       :_fun(fun)
//       ,_joinenable(true)
//       ,_status(STATUS::NEW)
//       {
//         _name="Thread" + std::to_string(number++);
//         _pid=getpid();
//       }
//       bool Start()
//       {
//             if(_status == STATUS::NEW)
//             {
//                 int n = pthread_create(&_tid,nullptr,Routine,this);
//                 if(n != 0)
//                 {
//                     std::cout<<"创建线程失败"<<std::endl;
//                     return false;
//                 }
//                  return true; 
//             }
//             return false;
      
//       }
//       bool Join()
//       {
//         if(_joinenable&&_status==STATUS::RUNING)
//         {
//             int n  = pthread_join(_tid,nullptr);
//             if(n!=0)
//             {
//                 std::cout<<"等待线程失败"<<std::endl;
//                 return false;
//             }
//             //join住了线程就要终止了
//             _status= STATUS::STOP;
//             return true;
//         }
//         return false;
//       }
//       bool Stop()
//       {
//             if(_status==STATUS::RUNING)
//             {
//                 int n = pthread_cancel(_tid);
//                 if(n != 0)
//                 {
//                     std::cout<<"终止线程失败"<<std::endl;
//                     return false;
//                 }
//                 _status=STATUS::STOP;
//                 return true;
//             }
//             return false;
//       }
//       void Detach()
//       {
//         _joinenable=false;
//         pthread_detach(_tid);
//       }
//       std::string Name()
//       {
//         return _name;
//       }
//       bool isJoin()//等待的状态 // 是否可以分离
//       {
//         return _joinenable;
//       }

//      private:
//         std::string _name;
//         pthread_t _tid;//线程的tid
//         pid_t _pid;//进程的pid
//         bool _joinenable;//是否被等待回收  默认是被等待 或 可不可以分离 否  
//         fun_c _fun;
//         STATUS _status;
//     };



// };

#endif